package org.utils.util;

public class StringUtils
{
  public static String newLine()
  {
  	return System.getProperty("line.separator");
  }
  /**
   * <code>StringBuffer</code> remplit avec 50 espaces
   * Cette object sert au remplissage des buffers avec des blancs
   */
  private static final StringBuffer stringFiller = new StringBuffer("                                                  ");

  /**
   * <code>StringBuffer</code> remplit avec 50 caract&egrave;res '0'
   * Cette object sert au remplissage des buffers avec des zeros
   */
  private static final StringBuffer numericFiller = new StringBuffer("00000000000000000000000000000000000000000000000000");

  /**
   * Compl&egrave;te le StringBuffer pass&eacute; en param&egrave;tre avec des espaces pour que la longueur
   * de sa valeur atteigne la valeur maximale pass&eacute;e en param&egrave;tre.
   *
   * @see java.lang.StringBuffer
   *
   * @param buffer Le buffer &agrave; completer
   * @param length La longueur du buffer
   * @param max La longueur maximale &agrave; atteindre
   */
  public static void getStringFiller(StringBuffer buffer, int length, int max)
  {
      fillIn(stringFiller, buffer, max - length);
  }

  /**
   * Compl&egrave;te le StringBuffer pass&eacute; en param&egrave;tre avec des z&eacute;ros pour que la longueur
   * de sa valeur atteigne la valeur maximale pass&eacute;e en param&egrave;tre.
   *
   * @see java.lang.StringBuffer
   *
   * @param buffer Le buffer &agrave; completer
   * @param length La longueur du buffer
   * @param max La longueur maximale &agrave; atteindre
   */
  public static void getNumericFiller(StringBuffer buffer, int length, int max)
  {
      fillIn(numericFiller, buffer, max - length);
  }

  /**
   * Renvoie une String avec un nombre d'espaces &eacute;gal &agrave; la diff&eacute;rence
   * entre la longueur pass&eacute;e en param&egrave;tre et la longueur maximale pass&eacute;e
   * elle aussi en param&egrave;tre.
   *
   * @param length La longueur courante
   * @param max La longueur maximale &agrave; atteindre
   *
   * @return Une String contenant le bon nombre d'espaces
   */
  public static String getStringFiller(int length, int max)
  {
      StringBuffer buffer = new StringBuffer();
      fillIn(stringFiller, buffer, max - length);
      return buffer.toString();
  }

  /**
   * Ajoute n caract&egrave;res dans le StringBuffer src &agrave; partir du StringBuffer dest.
   * Le nombre de caract&egrave;res &agrave; ajouter est pass&eacute en param&egrave;tre
   *
   * @see java.lang.StringBuffer
   *
   * @param src Le buffer &agrave; completer
   * @param dest Le buffer &agrave; partir duquel on prend les caract&egrave;res
   * @param length Le nombre de caract&egrave;res &agrave; ajouter
   */
  private static void fillIn(StringBuffer src, StringBuffer dest, int length)
  {
      int fillerLength = src.length();
      while (length > fillerLength)
      {
	dest.append(src.toString());
	length -= fillerLength;
      }
      dest.append(src.substring(0, length));
  }

  /**
   * Cette m&eacute;thode formate le montant pass&eacute;e en param&egrave;tre en &ocirc;tant
   * le signe du montant et la virgule qui s&eacute;pare les d&eacute;cimales
   *
   * @param montant Le montant &agrave; formater
   *
   * @return Une String sans le signe du montant ni la virgule qui s&eacute;pare les d&eacute;cimales
   */
  public static String removeDecimalSeparator(String montant)
  {
      if (montant.length() == 0)
	return montant;
      StringBuffer value = new StringBuffer(montant);
      int pos = montant.indexOf(',');
      if (pos > 0)
	value.deleteCharAt(pos);
      if ((montant.charAt(0) == '-') || (montant.charAt(0) == '+'))
	value.deleteCharAt(0);
      return value.toString();
  }

  /**
   * Calcule le nombre de d&eacute;cimales du montant pass&eacute; en param&egrave;tre.
   *
   * @param montant Le montant
   *
   * @return Retourne le nombre de d&eacute;cimales du montant pass&eacute; en param&egrave;tre.
   */
  public static int getDecimalCount(String montant)
  {
      // Calcule le nombre de decimales a partir du montant
      return montant.length() - (montant.lastIndexOf(',')+1);
  }

  /**
   * Compte le nombre d'occurence du caract&egrave;re pass&eacute; en param&egrave;tre dans la
   * String pass&eacute;e en param&egrave;tre
   *
   * @param c Le caract&egrave;re &agrave; chercher
   * @param str La String &agrave; parcourir
   *
   * @return Retourne le nombre d'occurence du caract&egrave;re pass&eacute; en param&egrave;tre
   */
  public static int countChar(char c, String str)
  {
      int pos = -1;
      int cpt = 0;
      while ( (pos = str.indexOf(c, pos+1)) >= 0)
      {
	      cpt++;
      }
      return cpt;
  }

  /**
   * Tronque la String pass&eacute;e en param&egrave;tre &agrave; partir de la fin
   *
   * @param str La String &agrave; tronquer
   * @param maxlength La longueur que la String doit avoir
   *
   * @return Retourne la String tronqu&eacute;e au bon nombre de caract&egrave;res
   */
  public static String truncateStringFromEnd(String str, int maxlength)
  {
    int length = str.length();
    if (length > maxlength)
    {
	    return str.substring(length - maxlength);
    }
    return str;
  }

  /**
   * D&eacute;coupe la chaine en deux. Le s&eacute;parateur est pass&eacute; en parametres
   *
   * @param str La String &agrave; d&eacute;couper
   * @param sep Le s&eacute;parateur
   *
   * @return Retourne un tableau de String
   */
   public static String[] split(String str, char sep)
   {
      int pos = str.indexOf(sep);
      if (pos < 0)
	      throw new RuntimeException("No such separator in \""+str+"\" (separator: "+sep+")");
      String[] splitted = {
	      str.substring(0, pos),
	      str.substring(pos+1)
      };
      return splitted;
   }

   public static String upperFirstLetter(String str)
   {
		char newChar = Character.toUpperCase(str.charAt(0));
		StringBuffer buffer = new StringBuffer(str);
		buffer.setCharAt(0, newChar);
		return buffer.toString();
   }
}
